{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "20bce0d3-6ea0-4db3-bc3b-2569027a0e3b",
        "showInput": false
      },
      "source": [
        "## Constrained, Parallel, Multi-Objective BO in BoTorch with qNEHVI, and qParEGO\n",
        "\n",
        "In this tutorial, we illustrate how to implement a constrained multi-objective (MO) Bayesian Optimization (BO) closed loop in BoTorch.\n",
        "\n",
        "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one, since this will simplify your setup (including the amount of code you need to write) considerably. See [here](https://ax.dev/docs/tutorials/multiobjective_optimization.html) for an Ax tutorial on MOBO. If desired, you can use a custom BoTorch model in Ax, following Ax's [Modular BoTorch tutorial](https://ax.dev/docs/tutorials/modular_botorch/) tutorial. Given a `MultiObjective`, Ax will default to the $q$NEHVI acquisiton function. If desired, this can also be customized by adding `\"botorch_acqf_class\": <desired_botorch_acquisition_function_class>,` to the `model_kwargs`.\n",
        "\n",
        "We use the parallel ParEGO ($q$ParEGO) [1] and parallel Noisy Expected Hypervolume Improvement ($q$NEHVI) [2]  acquisition functions to optimize a synthetic C2-DTLZ2 test function with $M=2$ objectives, $V=1$ constraint, and $d=4$ parameters. The two objectives are\n",
        "$$f_1(\\mathbf x) = (1+ g(\\mathbf x_M))\\cos\\big(\\frac{\\pi}{2}x_1\\big)$$\n",
        "$$f_2(\\mathbf x) = (1+ g(\\mathbf x_M))\\sin\\big(\\frac{\\pi}{2}x_1\\big)$$\n",
        "where $g(\\mathbf x) = \\sum_{x_i \\in \\mathbf x_M} (x_i - 0.5)^2, \\mathbf x \\in [0,1]^d,$ and $\\mathbf x_M$ represents the last $d - M +1$ elements of $\\mathbf x$. Additionally, the C2-DTLZ2 problem uses the following constraint:\n",
        "\n",
        "$$c(\\mathbf x) = - \\min \\bigg[\\min_{i=1}^M\\bigg((f_i(\\mathbf x) -1 )^2 + \\sum_{j=1, j=i}^M (f_j^2 - r^2) \\bigg), \\bigg(\\sum_{i=1}^M \\big((f_i(\\mathbf x) - \\frac{1}{\\sqrt{M}})^2 - r^2\\big)\\bigg)\\bigg]\\geq 0$$\n",
        "\n",
        "where $\\mathbf x \\in [0,1]^d$ and $r=0.2$. \n",
        "\n",
        "The goal here is to *minimize* both objectives. Since BoTorch assumes maximization, we maximize the negative of each objective. Since there typically is no single best solution in multi-objective optimization problems, we seek to find the pareto frontier, the set of optimal trade-offs where improving one metric means deteriorating another.\n",
        "\n",
        "[1] [S. Daulton, M. Balandat, and E. Bakshy. Differentiable Expected Hypervolume Improvement for Parallel Multi-Objective Bayesian Optimization. Advances in Neural Information Processing Systems 33, 2020.](https://arxiv.org/abs/2006.05078)\n",
        "\n",
        "[2] [S. Daulton, M. Balandat, and E. Bakshy. Parallel Bayesian Optimization of Multiple Noisy Objectives with Expected Hypervolume Improvement. Advances in Neural Information Processing Systems 34, 2021.](https://arxiv.org/abs/2105.08195)\n",
        "\n",
        "**For batch optimization (or in noisy settings), we strongly recommend using $q$NEHVI rather than $q$EHVI [1] because it is far more efficient than $q$EHVI and mathematically equivalent in the noiseless setting.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "00d9f0ef-fab6-463e-a54d-a548581bc7f4",
        "showInput": false
      },
      "source": [
        "### Set dtype and device\n",
        "Note: $q$EHVI aggressively exploits parallel hardware and is much faster when run on a GPU. See [1] for details."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Install dependencies if we are running in colab\n",
        "import sys\n",
        "if 'google.colab' in sys.modules:\n",
        "    %pip install botorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "customOutput": null,
        "executionStartTime": 1668651350300,
        "executionStopTime": 1668651350308,
        "originalKey": "f27224aa-b567-4a6d-b6b3-74f2ecbfe319",
        "requestMsgId": "df1b7814-2d71-4421-b832-e10d0c1e7743"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import torch\n",
        "\n",
        "\n",
        "tkwargs = {\n",
        "    \"dtype\": torch.double,\n",
        "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
        "}\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "89f8b99f-5cb2-45c9-9df6-7e1d18d4f8c6",
        "showInput": false
      },
      "source": [
        "### Problem setup\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "customOutput": null,
        "executionStartTime": 1668651350608,
        "executionStopTime": 1668651354486,
        "originalKey": "4227f250-60b5-4c97-b04c-3cfe7a1c410a",
        "requestMsgId": "83e67907-72c3-4bb8-8468-7eb99e616730"
      },
      "outputs": [],
      "source": [
        "from botorch.test_functions.multi_objective import C2DTLZ2\n",
        "\n",
        "\n",
        "d = 4\n",
        "M = 2\n",
        "problem = C2DTLZ2(dim=d, num_objectives=M, negate=True).to(**tkwargs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "2de9fbab-9d15-4410-8371-d3b1f730e3d7",
        "showInput": false
      },
      "source": [
        "#### Model initialization\n",
        "\n",
        "We use a multi-output `SingleTaskGP` to model the two objectives with a homoskedastic Gaussian likelihood with an inferred noise level.\n",
        "\n",
        "The models are initialized with $2(d+1)=10$ points drawn randomly from $[0,1]^{4}$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "code_folding": [],
        "customOutput": null,
        "executionStartTime": 1668651354720,
        "executionStopTime": 1668651354729,
        "hidden_ranges": [],
        "originalKey": "192b8d87-b2e3-4223-b193-6399b8643391",
        "requestMsgId": "55d97599-5be9-4a7a-857c-18a9b56bf07d"
      },
      "outputs": [],
      "source": [
        "from botorch.models.gp_regression import SingleTaskGP\n",
        "from botorch.models.model_list_gp_regression import ModelListGP\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "from botorch.utils.transforms import normalize, unnormalize\n",
        "from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood\n",
        "\n",
        "\n",
        "def generate_initial_data(n):\n",
        "    # generate training data\n",
        "    train_x = draw_sobol_samples(bounds=problem.bounds, n=n, q=1).squeeze(1)\n",
        "    train_obj = problem(train_x)\n",
        "    # negative values imply feasibility in botorch\n",
        "    train_con = -problem.evaluate_slack(train_x)\n",
        "    return train_x, train_obj, train_con\n",
        "\n",
        "\n",
        "def initialize_model(train_x, train_obj, train_con):\n",
        "    # define models for objective and constraint\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    train_y = torch.cat([train_obj, train_con], dim=-1)\n",
        "    models = []\n",
        "    for i in range(train_y.shape[-1]):\n",
        "        models.append(\n",
        "            SingleTaskGP(train_x, train_y[..., i : i + 1])\n",
        "        )\n",
        "    model = ModelListGP(*models)\n",
        "    mll = SumMarginalLogLikelihood(model.likelihood, model)\n",
        "    return mll, model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "a0f6fa02-0843-4c45-8a19-8654226c1edc",
        "showInput": false
      },
      "source": [
        "#### Define a helper function that performs the essential BO step for $q$NEHVI\n",
        "The helper function below initializes the $q$NEHVI acquisition function, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "For this example, we'll use a small batch of $q=2$. Passing the keyword argument `sequential=True` to the function `optimize_acqf`specifies that candidates should be optimized in a sequential greedy fashion (see [1] for details why this is important). A simple initialization heuristic is used to select the 10 restart initial locations from a set of 512 random points. Multi-start optimization of the acquisition function is performed using LBFGS-B with exact gradients computed via auto-differentiation.\n",
        "\n",
        "**Reference Point**\n",
        "\n",
        "$q$NEHVI requires specifying a reference point, which is the lower bound on the objectives used for computing hypervolume. In this tutorial, we assume the reference point is known. In practice the reference point can be set 1) using domain knowledge to be slightly worse than the lower bound of objective values, where the lower bound is the minimum acceptable value of interest for each objective, or 2) using a dynamic reference point selection strategy.\n",
        "\n",
        "**Integrating over function values at in-sample designs**\n",
        "\n",
        "$q$NEHVI integrates over the unknown function values at the previously evaluated designs (see [2] for details). Therefore, we need to provide the previously evaluated designs (`train_x`, *normalized* to be within $[0,1]^d$) to the acquisition function.\n",
        "\n",
        "**Pruning baseline designs**\n",
        "To speed up integration over the function values at the previously evaluated designs, we prune the set of previously evaluated designs (by setting `prune_baseline=True`) to only include those which have positive probability of being on the current in-sample Pareto frontier."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "code_folding": [],
        "customOutput": null,
        "executionStartTime": 1668651354970,
        "executionStopTime": 1668651355060,
        "hidden_ranges": [],
        "originalKey": "65dcfbb2-f1e9-40a1-9807-8cdc1cc3fdc8",
        "requestMsgId": "68a072df-7e90-4c7f-9915-520ca48c5e0a"
      },
      "outputs": [],
      "source": [
        "from botorch.acquisition.multi_objective.monte_carlo import (\n",
        "    qNoisyExpectedHypervolumeImprovement,\n",
        ")\n",
        "from botorch.acquisition.multi_objective.objective import IdentityMCMultiOutputObjective\n",
        "from botorch.optim.optimize import optimize_acqf, optimize_acqf_list\n",
        "from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization\n",
        "from botorch.utils.sampling import sample_simplex\n",
        "\n",
        "\n",
        "BATCH_SIZE = 2\n",
        "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n",
        "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n",
        "\n",
        "standard_bounds = torch.zeros(2, problem.dim, **tkwargs)\n",
        "standard_bounds[1] = 1\n",
        "\n",
        "\n",
        "def optimize_qnehvi_and_get_observation(model, train_x, train_obj, train_con, sampler):\n",
        "    \"\"\"Optimizes the qNEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    acq_func = qNoisyExpectedHypervolumeImprovement(\n",
        "        model=model,\n",
        "        ref_point=problem.ref_point.tolist(),  # use known reference point\n",
        "        X_baseline=train_x,\n",
        "        sampler=sampler,\n",
        "        prune_baseline=True,\n",
        "        # define an objective that specifies which outcomes are the objectives\n",
        "        objective=IdentityMCMultiOutputObjective(outcomes=[0, 1]),\n",
        "        # specify that the constraint is on the last outcome\n",
        "        constraints=[lambda Z: Z[..., -1]],\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values\n",
        "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj = problem(new_x)\n",
        "    # negative values imply feasibility in botorch\n",
        "    new_con = -problem.evaluate_slack(new_x)\n",
        "    return new_x, new_obj, new_con"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "ae9e19c2-327f-486e-bee3-11f1b71b0dfe",
        "showInput": false
      },
      "source": [
        "#### Define a helper function that performs the essential BO step for $q$ParEGO\n",
        "The helper function below similarly initializes $q$ParEGO, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "$q$ParEGO uses random augmented chebyshev scalarization with the `qExpectedImprovement` acquisition function. In the parallel setting ($q>1$), each candidate is optimized in sequential greedy fashion using a different random scalarization (see [1] for details).\n",
        "\n",
        "To do this, we create a list of `qExpectedImprovement` acquisition functions, each with different random scalarization weights. The `optimize_acqf_list` method sequentially generates one candidate per acquisition function and conditions the next candidate (and acquisition function) on the previously selected pending candidates."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "code_folding": [],
        "customOutput": null,
        "executionStartTime": 1668651355591,
        "executionStopTime": 1668651355682,
        "hidden_ranges": [],
        "originalKey": "a4a23da4-64de-4948-ad92-76b57c023f62",
        "requestMsgId": "f38f70dd-4857-484f-963c-cdfec7d8fc67"
      },
      "outputs": [],
      "source": [
        "from botorch.acquisition.monte_carlo import qExpectedImprovement\n",
        "from botorch.acquisition.objective import GenericMCObjective\n",
        "\n",
        "\n",
        "def optimize_qparego_and_get_observation(model, train_obj, train_con, sampler):\n",
        "    \"\"\"Samples a set of random weights for each candidate in the batch, performs sequential greedy optimization\n",
        "    of the qParEGO acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    acq_func_list = []\n",
        "    for _ in range(BATCH_SIZE):\n",
        "        # sample random weights\n",
        "        weights = sample_simplex(problem.num_objectives, **tkwargs).squeeze()\n",
        "        # construct augmented Chebyshev scalarization\n",
        "        scalarization = get_chebyshev_scalarization(weights=weights, Y=train_obj)\n",
        "        # initialize the scalarized objective (w/o constraints)\n",
        "        scalarized_objective = GenericMCObjective(\n",
        "            # the last element of the model outputs is the constraint\n",
        "            lambda Z, X: scalarization(Z[..., :-1]),\n",
        "        )\n",
        "        train_y = torch.cat([train_obj, train_con], dim=-1)\n",
        "        acq_func = qExpectedImprovement(  # pyre-ignore: [28]\n",
        "            model=model,\n",
        "            objective=scalarized_objective,\n",
        "            best_f=scalarized_objective(train_y).max(),\n",
        "            constraints=[lambda Z: Z[..., -1]],\n",
        "            sampler=sampler,\n",
        "        )\n",
        "        acq_func_list.append(acq_func)\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf_list(\n",
        "        acq_function_list=acq_func_list,\n",
        "        bounds=standard_bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "    )\n",
        "    # observe new values\n",
        "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj = problem(new_x)\n",
        "    # negative values imply feasibility in botorch\n",
        "    new_con = -problem.evaluate_slack(new_x)\n",
        "    return new_x, new_obj, new_con"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "d4487ba0-4fad-41dd-a2ae-e0b95094dba1",
        "showInput": false
      },
      "source": [
        "### Perform Bayesian Optimization loop with $q$EHVI and $q$ParEGO\n",
        "The Bayesian optimization \"loop\" for a batch size of $q$ simply iterates the following steps:\n",
        "1. given a surrogate model, choose a batch of points $\\{x_1, x_2, \\ldots x_q\\}$\n",
        "2. observe $f(x)$ for each $x$ in the batch \n",
        "3. update the surrogate model. \n",
        "\n",
        "\n",
        "Just for illustration purposes, we run one trial with `N_BATCH=20` rounds of optimization. The acquisition function is approximated using `MC_SAMPLES=128` samples.\n",
        "\n",
        "*Note*: Running this may take a little while."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "code_folding": [],
        "customOutput": null,
        "executionStartTime": 1668651356028,
        "executionStopTime": 1668651959470,
        "hidden_ranges": [],
        "originalKey": "4c225d99-6425-4201-ac4a-a042a351c1d3",
        "requestMsgId": "be831f3c-ff7c-4c00-a215-fb021f0c5770"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Batch  1: Hypervolume (random, qParEGO, qNEHVI) = (0.00, 0.00, 0.00), time = 4.54.\n",
            "Batch  2: Hypervolume (random, qParEGO, qNEHVI) = (0.00, 0.00, 0.00), time = 4.12.\n",
            "Batch  3: Hypervolume (random, qParEGO, qNEHVI) = (0.13, 0.00, 0.10), time = 4.10.\n",
            "Batch  4: Hypervolume (random, qParEGO, qNEHVI) = (0.13, 0.00, 0.14), time = 4.49.\n",
            "Batch  5: Hypervolume (random, qParEGO, qNEHVI) = (0.13, 0.00, 0.17), time = 4.65.\n",
            "Batch  6: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.00, 0.23), time = 5.38.\n",
            "Batch  7: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.06, 0.25), time = 6.17.\n",
            "Batch  8: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.12, 0.27), time = 5.26.\n",
            "Batch  9: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.19, 0.28), time = 6.60.\n",
            "Batch 10: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.20, 0.28), time = 6.12.\n",
            "Batch 11: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.23, 0.32), time = 6.05.\n",
            "Batch 12: Hypervolume (random, qParEGO, qNEHVI) = (0.16, 0.25, 0.34), time = 6.76.\n",
            "Batch 13: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.25, 0.35), time = 6.47.\n",
            "Batch 14: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.27, 0.36), time = 7.86.\n",
            "Batch 15: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.28, 0.36), time = 5.15.\n",
            "Batch 16: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.28, 0.36), time = 5.09.\n",
            "Batch 17: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.31, 0.37), time = 7.28.\n",
            "Batch 18: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.32, 0.37), time = 7.97.\n",
            "Batch 19: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.34, 0.37), time = 8.76.\n",
            "Batch 20: Hypervolume (random, qParEGO, qNEHVI) = (0.17, 0.34, 0.38), time = 5.98."
          ]
        }
      ],
      "source": [
        "import time\n",
        "import warnings\n",
        "\n",
        "from botorch import fit_gpytorch_mll\n",
        "from botorch.exceptions import BadInitialCandidatesWarning\n",
        "from botorch.sampling.normal import SobolQMCNormalSampler\n",
        "from botorch.utils.multi_objective.hypervolume import Hypervolume\n",
        "from botorch.utils.multi_objective.pareto import is_non_dominated\n",
        "\n",
        "\n",
        "warnings.filterwarnings(\"ignore\", category=BadInitialCandidatesWarning)\n",
        "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
        "\n",
        "N_BATCH = 20 if not SMOKE_TEST else 1\n",
        "MC_SAMPLES = 128 if not SMOKE_TEST else 16\n",
        "verbose = True\n",
        "\n",
        "hv = Hypervolume(ref_point=problem.ref_point)\n",
        "hvs_qparego, hvs_qnehvi, hvs_random = [], [], []\n",
        "\n",
        "# call helper functions to generate initial training data and initialize model\n",
        "train_x_qparego, train_obj_qparego, train_con_qparego = generate_initial_data(\n",
        "    n=2 * (d + 1)\n",
        ")\n",
        "mll_qparego, model_qparego = initialize_model(\n",
        "    train_x_qparego, train_obj_qparego, train_con_qparego\n",
        ")\n",
        "\n",
        "train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_con_qparego,\n",
        ")\n",
        "train_x_random, train_obj_random, train_con_random = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_con_qparego,\n",
        ")\n",
        "\n",
        "mll_qnehvi, model_qnehvi = initialize_model(\n",
        "    train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi\n",
        ")\n",
        "\n",
        "# compute pareto front\n",
        "is_feas = (train_con_qparego <= 0).all(dim=-1)\n",
        "feas_train_obj = train_obj_qparego[is_feas]\n",
        "if feas_train_obj.shape[0] > 0:\n",
        "    pareto_mask = is_non_dominated(feas_train_obj)\n",
        "    pareto_y = feas_train_obj[pareto_mask]\n",
        "    # compute hypervolume\n",
        "    volume = hv.compute(pareto_y)\n",
        "else:\n",
        "    volume = 0.0\n",
        "\n",
        "hvs_qparego.append(volume)\n",
        "hvs_qnehvi.append(volume)\n",
        "hvs_random.append(volume)\n",
        "\n",
        "# run N_BATCH rounds of BayesOpt after the initial random batch\n",
        "for iteration in range(1, N_BATCH + 1):\n",
        "    t0 = time.monotonic()\n",
        "\n",
        "    # fit the models\n",
        "    fit_gpytorch_mll(mll_qparego)\n",
        "    fit_gpytorch_mll(mll_qnehvi)\n",
        "\n",
        "    # define the qParEGO and qNEHVI acquisition modules using a QMC sampler\n",
        "    qparego_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qnehvi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "\n",
        "    # optimize acquisition functions and get new observations\n",
        "    (\n",
        "        new_x_qparego,\n",
        "        new_obj_qparego,\n",
        "        new_con_qparego,\n",
        "    ) = optimize_qparego_and_get_observation(\n",
        "        model_qparego, train_obj_qparego, train_con_qparego, qparego_sampler\n",
        "    )\n",
        "    new_x_qnehvi, new_obj_qnehvi, new_con_qnehvi = optimize_qnehvi_and_get_observation(\n",
        "        model_qnehvi, train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi, qnehvi_sampler\n",
        "    )\n",
        "    new_x_random, new_obj_random, new_con_random = generate_initial_data(n=BATCH_SIZE)\n",
        "\n",
        "    # update training points\n",
        "    train_x_qparego = torch.cat([train_x_qparego, new_x_qparego])\n",
        "    train_obj_qparego = torch.cat([train_obj_qparego, new_obj_qparego])\n",
        "    train_con_qparego = torch.cat([train_con_qparego, new_con_qparego])\n",
        "\n",
        "    train_x_qnehvi = torch.cat([train_x_qnehvi, new_x_qnehvi])\n",
        "    train_obj_qnehvi = torch.cat([train_obj_qnehvi, new_obj_qnehvi])\n",
        "    train_con_qnehvi = torch.cat([train_con_qnehvi, new_con_qnehvi])\n",
        "\n",
        "    train_x_random = torch.cat([train_x_random, new_x_random])\n",
        "    train_obj_random = torch.cat([train_obj_random, new_obj_random])\n",
        "    train_con_random = torch.cat([train_con_random, new_con_random])\n",
        "\n",
        "    # update progress\n",
        "    for hvs_list, train_obj, train_con in zip(\n",
        "        (hvs_random, hvs_qparego, hvs_qnehvi),\n",
        "        (train_obj_random, train_obj_qparego, train_obj_qnehvi),\n",
        "        (train_con_random, train_con_qparego, train_con_qnehvi),\n",
        "    ):\n",
        "        # compute pareto front\n",
        "        is_feas = (train_con <= 0).all(dim=-1)\n",
        "        feas_train_obj = train_obj[is_feas]\n",
        "        if feas_train_obj.shape[0] > 0:\n",
        "            pareto_mask = is_non_dominated(feas_train_obj)\n",
        "            pareto_y = feas_train_obj[pareto_mask]\n",
        "            # compute feasible hypervolume\n",
        "            volume = hv.compute(pareto_y)\n",
        "        else:\n",
        "            volume = 0.0\n",
        "        hvs_list.append(volume)\n",
        "\n",
        "    # reinitialize the models so they are ready for fitting on next iteration\n",
        "    # Note: we find improved performance from not warm starting the model hyperparameters\n",
        "    # using the hyperparameters from the previous iteration\n",
        "    mll_qparego, model_qparego = initialize_model(\n",
        "        train_x_qparego, train_obj_qparego, train_con_qparego\n",
        "    )\n",
        "    mll_qnehvi, model_qnehvi = initialize_model(\n",
        "        train_x_qnehvi, train_obj_qnehvi, train_con_qnehvi\n",
        "    )\n",
        "\n",
        "    t1 = time.monotonic()\n",
        "\n",
        "    if verbose:\n",
        "        print(\n",
        "            f\"\\nBatch {iteration:>2}: Hypervolume (random, qParEGO, qNEHVI) = \"\n",
        "            f\"({hvs_random[-1]:>4.2f}, {hvs_qparego[-1]:>4.2f}, {hvs_qnehvi[-1]:>4.2f}), \"\n",
        "            f\"time = {t1-t0:>4.2f}.\",\n",
        "            end=\"\",\n",
        "        )\n",
        "    else:\n",
        "        print(\".\", end=\"\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "3132af99-128f-41fc-9e6c-d1eaf6083f81",
        "showInput": false
      },
      "source": [
        "#### Plot the results\n",
        "The plot below shows the log feasible hypervolume difference: the log difference between the hypervolume of the true feasible pareto front and the hypervolume of the observed (feasible) pareto front identified by each algorithm. The log feasible hypervolume difference is plotted at each step of the optimization for each of the algorithms.\n",
        "\n",
        "The plot show that $q$NEHVI vastly outperforms the $q$ParEGO and Sobol baselines."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "code_folding": [],
        "customOutput": null,
        "executionStartTime": 1668651959825,
        "executionStopTime": 1668651960985,
        "hidden_ranges": [],
        "originalKey": "38f5ce01-264f-43bd-8bdb-edf756f7c0dc",
        "requestMsgId": "ec2a65b4-0cdb-4487-b6f4-da16df97ce18"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x17f7b6380>"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "\n",
        "iters = np.arange(N_BATCH + 1) * BATCH_SIZE\n",
        "log_hv_difference_qparego = np.log10(problem.max_hv - np.asarray(hvs_qparego))\n",
        "log_hv_difference_qnehvi = np.log10(problem.max_hv - np.asarray(hvs_qnehvi))\n",
        "log_hv_difference_rnd = np.log10(problem.max_hv - np.asarray(hvs_random))\n",
        "\n",
        "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
        "ax.plot(\n",
        "    iters,\n",
        "    log_hv_difference_rnd,\n",
        "    label=\"Sobol\",\n",
        "    linewidth=1.5,\n",
        "    color=\"gray\",\n",
        ")\n",
        "ax.plot(\n",
        "    iters,\n",
        "    log_hv_difference_qparego,\n",
        "    label=\"qParEGO\",\n",
        "    linewidth=1.5,\n",
        "    color=\"red\",\n",
        ")\n",
        "ax.plot(\n",
        "    iters,\n",
        "    log_hv_difference_qnehvi,\n",
        "    label=\"qNEHVI\",\n",
        "    linewidth=1.5,\n",
        "    color=\"blue\",\n",
        ")\n",
        "ax.set(\n",
        "    xlabel=\"number of observations (beyond initial points)\",\n",
        "    ylabel=\"Log Hypervolume Difference\",\n",
        ")\n",
        "ax.legend(loc=\"lower right\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "collapsed": true,
        "hidden_ranges": [],
        "originalKey": "a926c260-dcc2-4ce9-9c53-7b75456c6c0c",
        "showInput": false
      },
      "source": [
        "#### Plot the observations colored by iteration\n",
        "\n",
        "To examine optimization process from another perspective, we plot the collected observations under each algorithm where the color corresponds to the BO iteration at which the point was collected. The plot on the right for $q$NEHVI shows that the $q$NEHVI quickly identifies the pareto front and most of its evaluations are very close to the pareto front. $q$ParEGO also identifies has many observations close to the pareto front, but relies on optimizing random scalarizations, which is a less principled way of optimizing the pareto front compared to $q$NEHVI, which explicitly attempts focuses on improving the pareto front. Sobol generates random points and has few points close to the pareto front"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "customOutput": null,
        "executionStartTime": 1668651961290,
        "executionStopTime": 1668651961935,
        "originalKey": "75cb7f30-5ed2-4a02-bf46-b5c660af6494",
        "requestMsgId": "fa568aad-a7cb-43e7-b7ec-eff622a5edc9"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/_j/_hhj7k4913d4jlzgq92bw9b00000gn/T/ipykernel_16702/4269187899.py:7: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n",
            "  cm = plt.get_cmap(\"viridis\")\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Iteration')"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1700x500 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from matplotlib.cm import ScalarMappable\n",
        "import matplotlib\n",
        "\n",
        "\n",
        "fig, axes = plt.subplots(1, 3, figsize=(17, 5))\n",
        "algos = [\"Sobol\", \"qParEGO\", \"qNEHVI\"]\n",
        "cm = plt.get_cmap(\"viridis\")\n",
        "\n",
        "batch_number = torch.cat(\n",
        "    [\n",
        "        torch.zeros(2 * (d + 1)),\n",
        "        torch.arange(1, N_BATCH + 1).repeat(BATCH_SIZE, 1).t().reshape(-1),\n",
        "    ]\n",
        ").numpy()\n",
        "\n",
        "for i, train_obj in enumerate((train_obj_random, train_obj_qparego, train_obj_qnehvi)):\n",
        "    sc = axes[i].scatter(\n",
        "        train_obj[:, 0].cpu().numpy(),\n",
        "        train_obj[:, 1].cpu().numpy(),\n",
        "        c=batch_number,\n",
        "        alpha=0.8,\n",
        "    )\n",
        "    axes[i].set_title(algos[i])\n",
        "    axes[i].set_xlabel(\"Objective 1\")\n",
        "    axes[i].set_xlim(-2.5, 0)\n",
        "    axes[i].set_ylim(-2.5, 0)\n",
        "axes[0].set_ylabel(\"Objective 2\")\n",
        "norm = plt.Normalize(batch_number.min(), batch_number.max())\n",
        "sm = ScalarMappable(norm=norm, cmap=cm)\n",
        "sm.set_array([])\n",
        "fig.subplots_adjust(right=0.9)\n",
        "cbar_ax = fig.add_axes([0.93, 0.15, 0.01, 0.7])\n",
        "cbar = fig.colorbar(sm, cax=cbar_ax)\n",
        "cbar.ax.set_title(\"Iteration\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "python3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
